//
//  main.cpp
//  learnC++
//
//  Created by apple on 2018/5/8.
//  Copyright © 2018年 yunfan.com. All rights reserved.
//

#include "headFile.hpp"
#include <unistd.h>
#include "fuxi.h"
//constexpr int max_num = 200;
int pow(int base, int exp);

int main(int argc, const char * argv[]) {
    // insert code here...

    char *haystack = "hello";
    char * needle = "";
    
    compareStrClass *compare = new compareStrClass(haystack);
    compare->compare(needle);
//    TestPtr *p = new TestPtr();
    
//    p->addRef();
    
//    ClassStruct c("alex","dell");
//
//    const ClassStruct *p = new ClassStruct("xx","cc");
//    p->m_age = 10;//do't use
    
//    c.printSelf();
//    c.m_age = "ss";
//    c.Struct2::m_name = "ss";
//    c.m_name = "ff";
////
//    ClassStruct2 c2("cccc","xxxxx");
//
//    std::cout << c2;
//
//    std::cout << c;
    
//    ThreadClass c;
//    c.creatThread();
//    c.creatP_thread();
    
//    RandomIO ra;
//    ra.TestRandomIO();
    
    
//    BasicFileIO fs;
//    fs.ofstreamTest();
//    fs.appendFile();
//    
//    StreamStatus ss;
//    ss.TestNum();
    
//    TestString2 ss;
//
//    ss.testStringStream();
    
//    Student2 st;
//    st.getValue();
//    st.printSelf();
//    st.m_value = 10;
    
//    std::string name = "alex";
//    TestString<std::string> str(name);
//
//    str.stringTest4();

//    STLContainers stl;
//    stl.TestMap();
//    stl.TestList();
//    stl.TestVector();
// printf("..");
//    Person3 p1;
//
//    Person3 p2(2);
//
//    TestPerson3(p1);
//

//    BaseballPlayer b(10,20);
//    testPerson(b);
    
//    auto ptr1 = std::make_shared<Resource7>();
//
//    auto ptr2 = ptr1;
//
//    ptr1.reset();
//
//    ptr2.reset();
//
//    printf("...");
    
//    ptr1->m_ptr = ptr1;
//
   
    
    
    
//    auto ptr1 = std::make_shared<Resource>();
//    {
//        auto ptr2 = ptr1;
//    }
    
//    Resource *res = new Resource();
//    std::shared_ptr<Resource> ptr1(res);
//    {
//        std::shared_ptr<Resource> *ptr2 = new std::shared_ptr<Resource>(ptr1);
//
//        delete ptr2;
//    }
    
//    auto dog = std::make_unique<Dog>(1);
//
//    People p(std::move(dog),12);
//
//    std::cout << "...";
//
//    std::unique_ptr<Fraction6> f1 = std::make_unique<Fraction6>(3,5);
//    std::cout << *f1 << "\n";
//
//    std::unique_ptr<Fraction6> f2 = std::unique_ptr<Fraction6>(new Fraction6(6,8));
//    std::cout << *f2 << "\n";
//
//    auto f3 = std::make_unique<Fraction6[]>(4);
//    std::cout << f3[0] << "\n";
    
    
//    auto f1 = std::make_unique<Fraction6>(3,5);
////    f1 = f1->takeOwnership(std::move(f1));
//    (*f1).printSelf(f1.get());
//
//    std::cout << *f1;
    
    
    
//    std::vector<std::string> v;
//
//    std::string str = "Knock";
//
//    std::cout << "Copy str\n";
//    v.push_back(str);
//
//    std::cout << "str: " << str << '\n';
//    std::cout << "vector: " << v[0] << '\n';
//
//    std::cout << "\nMoving str\n";
//
//    v.push_back(std::move(str));
//
//    std::cout << "str: " << str << "\n";
//    std::cout << "vector:" << v[0] << ' ' << v[1] << '\n';
//
    
//    0.00274284
    //0.00223468
//    AutoPtr4<Resource4> ap;
//
//    ap = generateResource2();
//    std::cout << "/////";
    
//    Fraction5 c(3,5);
//
//    int x= 10;
//
//    c.fun(x);
//    c.fun(3);
    
//    const int a = 10;
//    const int &b = a;
    
//    AutoPtr2<Resource2> ap1(new Resource2);
//
//    AutoPtr2<Resource2> ap2;
//
//    std::cout << "res1 is " << (ap1.isNull() ? "null\n" : "not null\n");
//    std::cout << "res2 is " << (ap2.isNull() ? "null\n" : "not null\n");
//
//    ap2 = ap1;
//
//    std::cout << "res1 is " << (ap1.isNull() ? "null\n" : "not null\n");
//    std::cout << "res2 is " << (ap2.isNull() ? "null\n" : "not null\n");
//
    
    
//    int *ptr = nullptr;
//
//    delete ptr;
    
//    Resource *re = new Resource();
//
//    AutoPtr1<Resource> ap(re);
//
    
//    CatchAllException c1;
    
//    int *p = new int(0);
    
//    try
//    {
//        B2 b(0);
//    }
//    catch (int)
//    {
//        std::cout << "Oops\n";
//    }
    
//    CatchError c;

//    c.base();
    
//    Pair1<int,double> p1(5,8.2);
//
//    std::cout << p1.first() << p1.second();
//
//
//    Pair1<double,int> p2(5.2,8);
//
//    std::cout << p2.first() << p2.second();
//
//    StringValuePair<int> n1("alex",12);
//    std::cout << n1.first() << n1.second();
    
//    char name[] = "alex";
//    size_t nb = strlen(name);
//    printf("%zu",nb);
    
//    std::cout << p2.first() << p2.second();
    
//    Storage5<int> is(5);
//    is.print();
//
//    int x = 7;
//    Storage5<int *> as(&x);
//    as.print();
//
//    x = 9;
//    as.print();
//
//    char name[] = "alex";
//    Storage5<char *> cs(name);
//
//    cs.print();
    
//        char name[] = "alex";
//
//    std::cout << *name;
//
//
//    Storage4<char *> cs(name);
//    cs.print();

//    Storage4<int> is(2);
    
    
//    StaticArray3<double, 4> ds;
//    for (int count = 0; count < 4; ++count)
//        ds[count] = (4. + 0.1*count);
//    ds.print();
//
//    StaticArray3<int, 6> intArray;
//    for (int count = 0; count < 6; ++count)
//        intArray[count] = count;
//    intArray.print();
//
//    StaticArray2<int, 4> is;
//    for (int i = 0; i < 4; ++i) {
//        is[i] = i;
//    }
//    printStaticArray(is);
//
//
//
//    StaticArray2<char, 14> char14;
//    strcpy(char14.getArray(), "hello,world!");
//    printStaticArray(char14);
//
//
//    StaticArray2<double, 4> ds;
//    for (int count = 0; count < 4; ++count)
//        ds[count] = (4.0 + 0.1 * count);
//    ds.print();
//
    
    
//    Storage8<int> is;
//
//    for (int i = 0; i < 8; ++i) {
//        is.set(i, i);
//    }
//
//    for (int i = 0; i < 8; ++i) {
//        std::cout << is.get(i) << "\n";
//    }
//
//    Storage8<bool> bs;
//    for (int i = 0; i < 8; ++i) {
//        bs.set(i, i);
//    }
//
//    for (int i = 0; i < 8; ++i) {
//        std::cout << bs.get(i) << "\n";
//    }
    
//    Storage8<double> ds;
    
//    StorageTwo<int> s1(1);
//    StorageTwo<double> s2(2.2);
//
//    s1.print();
//    s2.print();
    
    
//    Array<int> iArr(10);
//    Array<double> dArr(10);
//
//    int length = iArr.getArrLength();
//    for (int i = 0; i < length; ++i) {
//        iArr[i] = i;
//        dArr[i] = i + 0.5;
//    }
//
//    std::cout << iArr << dArr;
    

//    int array1[] = { 5, 3, 2, 1, 4 };
//    std::cout << average(array1, 5) << '\n';
//
    
//    Derived12 a(1,"apple");
//
//    Base12 &b = a;
//
//
//
//    Derived12 &d = dynamic_cast<Derived12 &>(b);
//    std::cout << "The name of the Derived is: " << d.getName() << '\n';
    
    
//    std::vector<std::reference_wrapper<Base11>> v;
//    Base11 b1("alex",3);
//    Derived11 d1("jack",5);
//
//    v.push_back(b1);
//    v.push_back(d1);
//
//    for (int count = 0; count < v.size(); ++count)
//        std::cout << "I am a " << v[count].get().getName() << " with value " << v[count].get().getValue() << "\n";
    
//    Base11 pb = d;//对象裁剪，会将d的基类部分完全赋值，派生类部分裁减掉
//
//    std::cout << pb.getName() << pb.getValue();
    
    
    
//    ScreenLog scr;
    
//    scr.openLog();
    
//    Cow c("mengNiu");
//
//    std::cout << c.speak();
    
//    Derived9 der(9);
//
//    Derived9 pd(2);
    
//    pd = der;
//    printf("%d,%d",pd.m_value,der.m_value);
    
//    Derived9 *d = new Derived9(3);
//
//    Base9 *base = d;
//
//    delete base;
    
//    Base8 b;
//    const char * str = b.getName();
//    printf("%s\n",str);
//    Derived8 d;
//    Base8 *pb = &d;
//    Base8 &rb = d;
//    const char * str = pb->getName();
//    const char * rstr = rb.getName();
//    printf("%s===%s\n",str,rstr);
    
//    Derived7 d(7);
//    D2 d = D2(3);
//    d.print();
//    d.Base6::print();
    
//    d.print();
//    d.Base6::print();
    
//    Teacher2 a = Teacher2("alex", 18, "manager", 12, 4);
//    std::string name = a.getName();
//
//    std::cout << name;
//    std::cout << name;
//    Derived3 d(5);
    
//    d.printValue();
    
//    d.m_value;
    
//    Pri p;
//    p.getPublic();
    
//    p.Base3::getPublic();
//    
//    const Derived der(30.0,10);
//
//    der.getCost();
//    der.getId();
//
//    std::cout << der.getId() << der.getCost() << std::endl;
    
//    BaseballPlayerSon son;
    
//    BaseballPlayer base(10,20);
//    base.m_name = "alex";
//    base.m_age = 18;
//    base.m_age = 18;
//
//    base.printSelf();
    
//    IntArray arr{1,2,3,4,5};
//
//    int value = arr[0];
//
//    value = 9;
//
//    printf("..\n");
    
//    for (int j=0; j<arr.getLength(); ++j)
//        std::cout << arr[j] << " ";
//
//    arr.insertBefore(9, 3);
//    for (int j=0; j<arr.getLength(); ++j)
//        std::cout << arr[j] << " ";
//
//    arr.insertAtEnd(4);
//
//    arr.erase();
//    for (int j=0; j<arr.getLength()-1; ++j)
//        std::cout << arr[j] << " ";
    

//    OperatorOverload a(10);
//    int p =  a(2,3);
//    printf("%d",p);
    
//    std::cout << a <<std::endl;
//
//    MyString3 m1("hello");
//    {
//
////        MyString3 m2(m1);
//        MyString3 m3("kkk");
//        m3 = m1;
////        std::cout << m2.getString();
//    }
//
//    std::cout << m1.getString();
    
//    MyString2 alex("alex",5);
//
//    MyString2 employ;
//    employ = alex;
//    std::cout << employ;
//    MyString mine = "x";
//    std::cout << makeNegative(6); // note the integer here
    
//    CentsFour cent(7);
//    cent.printInt(cent);
//
//
//    CentsFour ss(cent);
//
//    int c = static_cast<int>(cent);
//    Matrix4x4 m;
//    m(0,0) = 4.5;
//    std::cout << m(0, 0);
    
//    GradeMap grades;
//    grades["Alex"] = 'A';
//    grades["Frank"] = 'B';
//    std::cout << "Joe has a grade of " << grades["Joe"] << '\n';
//    std::cout << "Frank has a grade of " << grades["Frank"] << '\n';
//    IntList list(4);
//
//    list[2] = 3;
    
    
//    CentsThree cents1(6);
//
//    CentsThree th = cents1 << 1;
    

//    std::cout << "I have " << cents2.getCents() << " cents.\n";
    
//    Point point(2.0,3.0,4.0);
//
//    std::cout << point;
    
    
//    CentsTwo c1(1);
//    CentsTwo c2(3);
//
//    CentsTwo c3 = 2 + c1 + 1;
//
//    std::cout << c3.getCents()<< "kk\n";
    
//    int a = 4 +(3^2);
//    printf("%d",a);
    
    //c++
    
//    Mytime *time = new Mytime();
    
//    Mytime time = Mytime();
    
//    sleep(2);
//
//    double ss = time->elapsed();
//
//    std::cout << ss << "kkk\n";
//
//    delete time;
    
//    Fruit apple(Fruit::APPLE);
    
//    Cents(6);
    
//    Storage storage(5, 6.7);
    
    
//    Display display(false);
//
//    display.displayItem(storage);
    
//    int &s = StaticFunc::getValue();
//    std::cout << StaticFunc::getValue() << "\n";
//    s += 1;
//    std::cout << StaticFunc::getValue() << "\n";
    
    
//    MyDate::m_static = 10;
    
//    Calc c(1);
//
//    c.add(2).sub(1).mult(3);
//
//    std::cout << c.getValue() << '\n';
    
//    栈上分配内存
//    TestDestructor des(10);
//
//    for (int count=0; count < 10; ++count)
//        des.setValue(count, count+1);
//
//    std::cout << "The value of element 5 is: " << des.getValue(5) << std::endl;
//
//    //堆上分配内存
//    TestDestructor *heap = new TestDestructor(2);
//    heap->setValue(0, 1);
//
//    delete heap;
    
    
    
//    OverlappingTwo over("joe");
//    overlappingClass over(5);
    
//    B b(5);
    
//    MemberInit mem(1,2.2,'c');
//    mem.print();
    
//    Fraction frac{3,5};//uniform initialization
//    Fraction frac(3,5);//direct initialization
//    Fraction six = Fraction(6);
//    Fraction seven = 7;
//    std::cout << frac.getNumerator() << "/" << frac.getDenominator() << '\n';
    
//    DateClass today {2020,10,4};
//    today.m_day = 16;
//    today.getDate();
    

//    TodayClass today;
//    today.setDate(12, 3, 2028);
//    today.print();
//
//    TodayClass yesterday;
//    yesterday.setDate(04, 24, 2018);
//
//    today.copyFrom(yesterday);
//    today.print();
    
//    EmployeeClass alex{"alex",02,3000.0};
//    EmployeeClass joe{"joe",03,3000.0};
//    alex.earn();
//    joe.earn();
    
//    alex.instanceMethod();
    
//    test_ellipsis();
    
//    test_assert();
//    test_error_exit();
//    test_recursion();
//    test_vector_advance();
//    test_function_point();
//    test_default_param();
//    test_func_overload();
//    test_return_value();
//    test_func_point();
//    test_function();
//    test_std_vector();
//    test_std_array();
//    test_pointer_multi_arr();
    
//    test_for_each();
//    test_reference_variable();
    
//    test_pointer_const();
//    xiaoMing m{10};
    
//    test_alloc_array();
//    test_new();
    
//    test_pointer();
//    test_multidemensional_arr();
//    test_sort();
    
//    test_array();
//    test_struct();
    
//    test_random_num();
//    test_cpp_random();
//    test_cin();
    
//    test_enum(COLOR_RED);
    
//    stringTest();
    
    
//    std::cout << "Hello, World!\n";
    
//    extern int g_y;
//    g_y = 12;
    
//    unsigned int a = 5;
//    int b = -10;
//
//    printf("%d\n",a+b);
    
    
    
//    std::cout << a+b <<std::endl;
    
//    int i = 100;
//    i = static_cast<int>(i / 3.0);
//
//    printf("%d\n",i);
//
//    using namespace std;
//
//    cout<< "....\n";
    
//    secondName::threeName::dosomthing();
//
//    first::dosomthing();
//
//    printf("g_y = %d\n",g_y);
//    printf("g_c = %d\n",secondName::g_c);
//
//
//
//    globalVariables *global = new globalVariables();
//    global->~globalVariables();

//    using std::cout;
//    cout << "OOOO\n";
    
    //    float x = 0.1 + 0.1;
//    if (x == 0.2){
//        printf("yes");
//    }else{
//        printf("no");
//    }
    
    
//    int x = 8 >> 1;
//    std::cout << x << "ddd" <<std::endl;
//
//    int num = 10;
//    constexpr int age = 10;
//    const int height = max_num;
//
//    printf("%f\n",constants::pi);
//
//    std::cout << num << age << height << std::endl;
//
//    printf("%d",pow(2, 3));
    
    //    double d1(100 - 99.99); // should equal 0.01
    //    double d2(10 - 9.99); // should equal 0.01
    //
    //    if (d1 == d2)
    //        std::cout << "d1 == d2" << "\n";
    //    else if (d1 > d2)
    //        std::cout << "d1 > d2" << "\n";
    //    else if (d1 < d2)
    //        std::cout << "d1 < d2" << "\n";
    
    
//    std::cout << "Input a keyboard character: "; // assume the user enters "abcd" (without quotes)
//
//    char ch;
//    std::cin >> ch; // ch = 'a', "bcd" is left queued.
//    std::cout << ch << " has ASCII code " << static_cast<int>(ch) << std::endl;
//
//    // Note: The following cin doesn't ask the user for input, it grabs queued input!
//    std::cin >> ch; // ch = 'b', "cd" is left queued.
//    std::cout << ch << " has ASCII code " << static_cast<int>(ch) << std::endl;
    
    
//    char ch = 'a';
//    char aa = 97;
//
//
//
//    int i = static_cast<int>(ch);
//
//    printf("%d = %d\n",i,aa);
//    std::cout << ch << aa << std::endl;
    
//    double zero = 0.0;
//    double posinf = 5.0 / zero; // positive infinity
//    std::cout << posinf << std::endl;
//
//    double neginf = -5.0 / zero; // negative infinity
//    std::cout << neginf << std::endl;
//
//    double nan = zero / zero; // not a number (mathematically invalid)
//    std::cout << nan << std::endl;
    
    
    
//    std::cout << std::setprecision(17);
//
//    double d1(1.0);
//    std::cout << d1 << std::endl;
//
//    double d2(0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1); // should equal 1.0
//    std::cout << d2 << std::endl;
    
    
//    std::cout << std::setprecision(16);
//    float f;
//    f = 9.87654321f; // f suffix means this number should be treated as a float
//    std::cout << f << std::endl;
//    f = 987.654321f;
//    std::cout << f << std::endl;
//    f = 987654.321f;
//    std::cout << f << std::endl;
//    f = 9876543.21f;
//    std::cout << f << std::endl;
//    f = 0.0000987654321f;
//    std::cout << f << std::endl;
    
    
    return 0;
}

int pow(int base, int exp)
{
    //2 , 3
    int result = 1;
    while (exp)
    {
        if (exp & 1)
            result *= base;
        exp >>= 1;
        base *= base;
    }
    
    return result;
}
